/*************************************************************************
                         TestCollection  -  description
                             -------------------
    debut                : 10 oct. 2009
    copyright            : (C) 2009 par Binome 3310
*************************************************************************/
//- Réalisation de la classe <TestCollection> (fichier TestCollection.cpp)-

//------------------------------------------------------------------ INCLUDE

//-------------------------------------------------------- Include systéme
#include <iostream>
using namespace std;

//------------------------------------------------------ Include personnel
#include "TestCollection.h"


int main() {
//Test du deuxième constructeur

	const int NB_ELEMENT = 7;
	const int SIZE = 10;
	float elements[NB_ELEMENT] = {3.14, 1.61, 2.0, 4.65, 3.14, 145.09, 0.001};

	cout << "****************************************" << endl;
	cout << "**** Tests du deuxième constructeur ****" << endl;
	cout << "****************************************" << endl;
	cout << endl;


	//Premier test: Création d'une collection non vide avec un nombre d'éléments inférieur à la capacité de la collection
	cout << "Premier test: " << endl;
	cout << "*************" << endl;
	Collection myCollection(SIZE,NB_ELEMENT,elements);
	cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl;
	cout << endl;
	cout << "Les éléments présents dans la collection sont: " << endl;
	myCollection.Display();
	cout << endl;

	/*Résultat attendu:
	****************************************
	**** Tests du deuxième constructeur ****
	****************************************

	Premier test:
	 *************
	La collection 'myCollection' est de capacité:10 et contient: 7 élément(s)

	Les éléments présents dans la collection sont:
	Indice dans la collection: 0, Valeur: 3.14
	Indice dans la collection: 1, Valeur: 1.61
	Indice dans la collection: 2, Valeur: 2
	Indice dans la collection: 3, Valeur: 4.65
	Indice dans la collection: 4, Valeur: 3.14
	Indice dans la collection: 5, Valeur: 145.09
	Indice dans la collection: 6, Valeur: 0.001
    */


	//Deuxième test: Création d'une collection avec un nombre d'élément supérieur strictement à la capacité
	cout << "Deuxième test: " << endl;
	cout << "**************" << endl;
	float testArray[0];
    Collection emptyCollection(2,0,testArray); //Correspond à l'appel au constructeur1 avec la taille 2
	cout << "La collection 'emptyCollection' est de capacité:" << emptyCollection.Capacity() << " et contient: " << emptyCollection.Count() << " élément(s)" << endl;
    emptyCollection.Display();
    cout << endl;

    /*Résultat attendu:
     Deuxième test:
     **************
	La collection 'emptyCollection' est de capacité:2 et contient: 0 élément(s)
	La collection est vide
     */

//Test de la méthode Add (ajoute un seul élément)

    cout << "***************************************************" << endl;
	cout << "**** Tests de la méthode ADD (un seul élément) ****" << endl;
	cout << "***************************************************" << endl;
	cout << endl;

    //Premier test: ajout d'un élément à une collection non pleine (dont le nombre d'éléments est inférieur strictement à la capacité de la collection)
	cout << "Premier test: Ajout d'un élément à emptyCollection" << endl;
	cout << "*************" << endl;
    if (emptyCollection.Add(19.5) == OK)
    {	cout << "L'élément présent dans la collection est: " << endl;
    	emptyCollection.Display();
    	cout << endl;
    	cout << "La collection 'emptyCollection' est de capacité:" << emptyCollection.Capacity() << " et contient: " << emptyCollection.Count() << " élément(s)" << endl;
    	cout << endl;
    }

    /*
     Résultat attendu:
     ***************************************************
     **** Tests de la méthode ADD (un seul élément) ****
     ***************************************************

     *Premier test: Ajout d'un élément à emptyCollection
     *************
	 L'élément présent dans la collection est:
	 Indice dans la collection: 0, Valeur: 19.5

	 La collection 'emptyCollection' est de capacité:2 et contient: 1 élément(s)
     */

    //Deuxième test: ajout d'un élément à une collection pleine
	cout << "Deuxième test: " << endl;
	cout << "**************" << endl;
	cout << "Modfication de la capacité de la collection afin qu'elle soit pleine..." << endl;
	emptyCollection.Resize(1); //Redimensionner la collection pour qu'elle soit pleine
	cout << "La collection 'emptyCollection' est de capacité:" << emptyCollection.Capacity() << " et contient: " << emptyCollection.Count() << " élément(s)" << endl;
	cout << "Appel de la méthode Add pour ajouter un élément" << endl;
    if (emptyCollection.Add(2009.0) == FULL)
    {
    	cout << "L'élément n'a pas été ajouté car la collection est pleine" << endl << endl;
    }

    /*Résultat attendu:
	 Deuxième test:
     **************
	 Modfication de la capacité de la collection afin qu'elle soit pleine...
	 La collection 'emptyCollection' est de capacité:1 et contient: 1 élément(s)
	 Appel de la méthode Add pour ajouter un élément
	 L'élément n'a pas été ajouté car la collection est pleine
     */

//Test de la méthode Add (ajoute une collection)

    cout << "*********************************************************" << endl;
	cout << "**** Tests de la méthode ADD (ajoute une collection) ****" << endl;
	cout << "*********************************************************" << endl;
	cout << endl;

    //Premier test: Le nombre d'éléments de la collection à ajouter est inférieur à la différence entre la capacité et le nombre d'éléments de la collection.
	cout << "Premier test: Ajout d'un élément à emptyCollection" << endl;
	cout << "*************" << endl;
    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl;
    cout << "Ajouter à 'myCollection' la collection 'emptyCollection'..." << endl;
    myCollection.Add(emptyCollection);
    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;

    /*Résultat attendu:
    *********************************************************
    **** Tests de la méthode ADD (ajoute une collection) ****
    *********************************************************

    Premier test: Ajout d'un élément à emptyCollection
     *************
	La collection 'myCollection' est de capacité:10 et contient: 7 élément(s)
	Ajouter à 'myCollection' la collection 'emptyCollection'...
	La collection 'myCollection' est de capacité:10 et contient: 8 élément(s)
     */

    //Deuxième test: Le nombre d'éléments de la collection à ajouter est supérieur à la différence entre la capacité et le nombre d'élément de la collection.
    cout << "Deuxième test:" << endl;
    cout << "**************" << endl;

    cout << "La collection emptyCollection est de capacité:" << emptyCollection.Capacity() << " et contient: " << emptyCollection.Count() << " élément(s)" << endl;

    cout << "Ajouter a 'emptyCollection' la collection 'myCollection'..." << endl;
    emptyCollection.Add(myCollection);

    cout << "La collection 'emptyCollection' est de capacité:" << emptyCollection.Capacity() << " et contient: " << emptyCollection.Count() << " élément(s)" << endl << endl;

    /* Résultat attendu:
     Deuxième test:
     **************
	La collection emptyCollection est de capacité:1 et contient: 1 élément(s)
	Ajouter a 'emptyCollection' la collection 'myCollection'...
	La collection 'emptyCollection' est de capacité:9 et contient: 9 élément(s)
     */

    //Troisième test: La collection à ajouter est vide
    cout << "Troisième test:" << endl;
    cout << "***************" << endl;

    Collection testCollection(SIZE);
    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl;
    cout << "Ajouter à 'myCollection' une collection vide..." << endl;
    myCollection.Add(testCollection);
    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;

    /*Resultat attendu:
    Troisième test:
     ***************
	La collection 'myCollection' est de capacité:10 et contient: 8 élément(s)
	Ajouter à 'myCollection' une collection vide...
	La collection 'myCollection' est de capacité:10 et contient: 8 élément(s)
    */

    //Quatrième test: La collection à laquelle on doit ajouter des éléments est vide
    cout << "Quatrième test:" << endl;
    cout << "***************" << endl;

    cout << "La collection 'collectionTest' est de capacité:" << testCollection.Capacity() << " et contient: " << testCollection.Count() << " élément(s)" << endl;
    cout << "Ajouter à 'testCollection' (vide) la collection myCollection... " << endl;
    testCollection.Add(myCollection);

    cout << "La collection 'testCollection' est de capacité:" << testCollection.Capacity() << " et contient: " << testCollection.Count() << " élément(s)" << endl << endl;
    /*Resultat attendu:
	 Quatrième test:
     ***************
	La collection 'colelctionTest' est de capacité:10 et contient: 0 élément(s)
	Ajouter à 'testCollection' (vide) la collection myCollection...
	La collection 'testCollection' est de capacité:10 et contient: 8 élément(s)
    */


    //Cinquième test: La collection est ajoutée à elle même
    cout << "Cinquième test:" << endl;
    cout << "***************" << endl;

    testCollection.Resize(30);
    cout << "La collection testCollection contient: " << testCollection.Count() << " et a une capacité de " << testCollection.Capacity() << endl;
    cout << "La collection 'testCollection' est de capacité:" << testCollection.Capacity() << " et contient: " << testCollection.Count() << " élément(s)" << endl;
    cout << "Ajouter testCollection à elle même..." << endl;
    testCollection.Add(testCollection);
    cout << "La collection 'testCollection' est de capacité:" << testCollection.Capacity() << " et contient: " << testCollection.Count() << " élément(s)" << endl << endl;

    /*Resultat attendu:
    Cinquième test:
	***************
	La collection testCollection contient: 8 et a une capacité de 30
	La collection 'testCollection' est de capacité:30 et contient: 8 élément(s)
	Ajouter testCollection à elle même...
	La collection 'testCollection' est de capacité:30 et contient: 16 élément(s)
    */

//Test de la méthode Remove

    cout << "************************************" << endl;
	cout << "**** Tests de la méthode Remove ****" << endl;
	cout << "************************************" << endl << endl;
    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
	cout << "Les éléments de la collection 'myCollection' sont: " << endl;
	myCollection.Display();
	cout << endl;

	/*Resultat attendu:
	************************************
	**** Tests de la méthode Remove ****
	************************************

	La collection 'myCollection' est de capacité:10 et contient: 8 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 3.14
	Indice dans la collection: 1, Valeur: 1.61
	Indice dans la collection: 2, Valeur: 2
	Indice dans la collection: 3, Valeur: 4.65
	Indice dans la collection: 4, Valeur: 3.14
	Indice dans la collection: 5, Valeur: 145.09
	Indice dans la collection: 6, Valeur: 0.001
	Indice dans la collection: 7, Valeur: 19.5

	*/

	//Premier test : retrait de l'élément dont l'indice vaut 3 de la collection
    cout << "Premier test:" << endl;
    cout << "*************" << endl;

	int testArray1[1] = {2};

    cout << "Retrait de l'élément dont l'indice vaut 2..." << endl;
	if (myCollection.Remove(1,testArray1) == OK)
    {
		cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
		cout << "Les éléments de la collection 'myCollection' sont: " << endl;
		myCollection.Display();
		cout << endl;
    }

	/*Resultat attendu:
	Premier test:
	*************
	Retrait de l'élément dont l'indice vaut 2...
	La collection 'myCollection' est de capacité:7 et contient: 7 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 3.14
	Indice dans la collection: 1, Valeur: 1.61
	Indice dans la collection: 2, Valeur: 4.65
	Indice dans la collection: 3, Valeur: 3.14
	Indice dans la collection: 4, Valeur: 145.09
	Indice dans la collection: 5, Valeur: 0.001
	Indice dans la collection: 6, Valeur: 19.5

	*/

	//Deuxième test: retrait de plusieurs éléments présents dont les indices n'apparaissent qu'une seule fois
    cout << "Deuxième test:" << endl;
    cout << "**************" << endl;
    cout << "Retrait des éléments dont les indices valent 0, 2 et 3..." << endl;

	int testArray2[3] = {2,3,0};

	if (myCollection.Remove(3,testArray2) == OK)
	    {
			cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
			cout << "Les éléments de la collection 'myCollection' sont: " << endl;
			myCollection.Display();
			cout << endl;
	    }

	/*Resultat attendu:
	Deuxième test:
	**************
	Retrait des éléments dont les indices valent 0, 2 et 3...
	La collection 'myCollection' est de capacité:4 et contient: 4 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 1.61
	Indice dans la collection: 1, Valeur: 145.09
	Indice dans la collection: 2, Valeur: 0.001
	Indice dans la collection: 3, Valeur: 19.5
	*/

	//Troisième test: Retrait d'un élément qui n'est pas dans la collection
    cout << "Troisième test:" << endl;
    cout << "***************" << endl;
    cout << "Retrait de l'élément 4 (non présent)..." << endl;

	int testArray3[1] = {4};

	if (myCollection.Remove(1,testArray3) == WARNING )
	{
		cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
		cout << "Les éléments de la collection 'myCollection' sont: " << endl;
		myCollection.Display();
		cout << endl;
	}

	/*Resultat attendu:
	Troisième test:
	***************
	Retrait de l'élément 4 (non présent)...
	La collection 'myCollection' est de capacité:4 et contient: 4 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 1.61
	Indice dans la collection: 1, Valeur: 145.09
	Indice dans la collection: 2, Valeur: 0.001
	Indice dans la collection: 3, Valeur: 19.5

	*/

	//Quatrième test: Retrait de plusieurs éléments qui ne sont pas dans la collection
    cout << "Quatrième test:" << endl;
    cout << "***************" << endl;
    cout << "Retrait des éléments 0 (présent),5 et 7 (absents)..." << endl;

	int testArray4[3] = {0,5,7};

	if (myCollection.Remove(3,testArray4) == WARNING )
	{
		cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
		cout << "Les éléments de la collection 'myCollection' sont: " << endl;
		myCollection.Display();
		cout << endl;
	}

	/*Resultat attendu:
	Quatrième test:
	***************
	Retrait des éléments 0 (présent),5 et 7 (absents)...
	La collection 'myCollection' est de capacité:3 et contient: 3 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 145.09
	Indice dans la collection: 1, Valeur: 0.001
	Indice dans la collection: 2, Valeur: 19.5
	*/

	//Cinquième test: Retrait plusieurs fois d'un même élément présent dans la collection
	 cout << "Cinquième test:" << endl;
	 cout << "***************" << endl;
	 cout << "Retrait des éléments 0, 0, 1 et 2..." << endl;

	 int testArray5[4] = {0,0,1,2};

	if (myCollection.Remove(4,testArray5) == WARNING )
	{
		cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
		myCollection.Display();
		cout << endl;
	}

	/*Resultat attendu:
	Cinquième test:
	***************
	Retrait des éléments 0, 0, 1 et 2...
	La collection 'myCollection' est de capacité:0 et contient: 0 élément(s)

	La collection est vide
	*/

	//Sixième test: Retrait d'un élement d'une collection vide
	cout << "Sixième test:" << endl;
	cout << "*************" << endl;
	cout << "Retrait de l'élément 2 (la collection est vide)..." << endl;

	int testArray6[1] = {2};

	if (myCollection.Remove(1,testArray6) == EMPTY )
	{
	    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
		myCollection.Display();
		cout << endl;
	}

	/*Resultat attendu:
	Sixième test:
	*************
	Retrait de l'élément 2 (la collection est vide)...
	La collection 'myCollection' est de capacité:0 et contient: 0 élément(s)

	La collection est vide
	*/

	//Septième test: Le nombre d'élément à retirer est nul
	cout << "Septième test:" << endl;
	cout << "**************" << endl;
	int testArray7[3] = {5,6,7};
	cout << "Ajout de l'élément 3.14 après ajustement de la capacité de 'myCollection'..." << endl;


	if (myCollection.Resize(10)==OK && myCollection.Add(3.14) == OK)
	{
	    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
	    cout << "Les éléments de la collection 'myCollection' sont: " << endl;
	    myCollection.Display();
		cout << endl;
	}

	cout << "Retrait d'un nombre nul d'éléments..." << endl;
	if (myCollection.Remove(0,testArray7) == OK )
	{
	    cout << "La collection 'myCollection' est de capacité:" << myCollection.Capacity() << " et contient: " << myCollection.Count() << " élément(s)" << endl << endl;
	    cout << "Les éléments de la collection 'myCollection' sont: " << endl;
	    myCollection.Display();
		cout << endl << endl;
	}

	/*Resultat attendu:
	Septième test:
	**************
	Ajout de l'élément 3.14 après ajustement de la capacité de 'myCollection'...
	La collection 'myCollection' est de capacité:10 et contient: 1 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 3.14

	Retrait d'un nombre nul d'éléments...
	La collection 'myCollection' est de capacité:1 et contient: 1 élément(s)

	Les éléments de la collection 'myCollection' sont:
	Indice dans la collection: 0, Valeur: 3.14
	*/

	return 0;
}
